#include <iostream>
#include "Thread.hpp"
#include <vector>
#include <unistd.h>
#include "LockGuard.hpp"
using namespace ThreadModle;

int tickets = 10000;

void route(ThreadData *td)
{
    while (true)//是一个代码块
    {   //LockGuard是一个类型，定义出来的；临时对象，会调用他的构造函数，自动进行加锁，
        //while循环结束或者break结束，该对象临时变量被释放，析构函数被调用，解锁
        //RAII风格的锁
        LockGuard lockguard(td->_lock);//定义一个临时对象，对区域进行保护

        if (tickets > 0)
        {
            // 抢票过程
            usleep(1000); // 1ms -> 抢票花费的时间
            printf("who: %s, get a ticket: %d\n", td->_name.c_str(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}

// pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;

// void route(ThreadData *td)
// {
//     //检验是否访问到的是同一把锁
//     // std::cout << td->_name <<"，mutex address: " << td->_lock << std::endl;
//     // sleep(1);
//     while (true)
//     {
//         pthread_mutex_lock(td->_lock); // 加锁

//         if (tickets > 0) // 只有票数大于0的时候才需要抢票
//         {
//             // 抢票过程
//             usleep(1000); // 1ms -> 抢票花费的时间
//             printf("who: %s, get a ticket: %d\n", td->_name.c_str(), tickets);
//             tickets--;
//             pthread_mutex_unlock(td->_lock);
//         }
//         else
//         {
//             pthread_mutex_unlock(td->_lock);
//             break;
//         }
//     }
// }

// 创建threadnum个线程
static int threadnum = 4;
int main()
{
    // 创建的是局部锁
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, nullptr);
    // 创建多线程
    std::vector<Thread> threads;
    for (int i = 0; i < threadnum; i++)
    {
        std::string name = "thread-" + std::to_string(i + 1);
        ThreadData *td = new ThreadData(name, &mutex); // 将线程名字与锁地址传递给ThreadData
        threads.emplace_back(name, route, td);         // 创建线程，将线程名字要执行的回调函数，以及回调函数的参数(线程参数)
    }
    // 统一启动
    for (auto &thread : threads)
    {
        thread.Start();
    }

    // 等待线程等待
    for (auto &thread : threads)
    {
        thread.Join();
    }
    pthread_mutex_destroy(&mutex);
}

// int main()
// {
//     Thread t1("thread-1", route);
//     Thread t2("thread-2", route);
//     Thread t3("thread-3", route);
//     Thread t4("thread-4", route);

//     t1.Start();
//     t2.Start();
//     t3.Start();
//     t4.Start();

//     t1.Join();
//     t2.Join();
//     t3.Join();
//     t4.Join();
// }

// const int gnum = 10;

// void Print(const std::string &name)
// {
//     int cnt = 1;
//     while (true)
//     {
//         std::cout << name << "，is running, cnt: " << cnt++ << std::endl;
//         sleep(1);
//     }
// }
// int main()
//  {
//      // 我在管理原生线程， 先描述，在组织
//      // 构建线程对象
//      std::vector<Thread> threads;
//      for (int i = 0; i < gnum; i++)
//      {
//          std::string name = "thread-" + std::to_string(i + 1);
//          threads.emplace_back(name, Print);
//          sleep(1);
//      }

//      // 统一启动
//      for (auto &thread : threads)
//      {
//          thread.Start();
//      }

//      sleep(10);

//      // 统一结束
//      for (auto &thread : threads)
//      {
//          thread.Stop();
//      }

//      // 等待线程等待
//      for (auto &thread : threads)
//      {
//          thread.Join();
//      }

//      return 0;
//  }